home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / news / inn1.000 / inn1.4sec-linux-src.tar / inn / samples / sendbatch < prev    next >
Text File  |  1993-01-29  |  5KB  |  211 lines
  1. #! /bin/sh
  2. ##  $Revision: 1.10 $
  3. ##  SH script to send UUCP batches out.  By Mike Cooper and Rich $alz.
  4. ##  Based on B News sendbatch 1.22 10/29/89.
  5.  
  6. ##  =()<. @<_PATH_SHELLVARS>@>()=
  7. . /news/lib/innshellvars
  8.  
  9. ##  Place to run a df, and amount of space needed.
  10. UUSPOOL=/usr/spool/uucp
  11. SPOOLFREE=20000
  12. ##  Program names and flags.  Most can be set on the command-line.
  13. C7=
  14. COMP=
  15. COMPFLAGS=
  16. COMPRESS=/usr/ucb/compress
  17. ECHO=
  18. ##  Not a config param since this is the remote rnews.
  19. RNEWS=rnews
  20. UUX=uux
  21. UUXFLAGS="- -r -n -gd"
  22. ##  Desired size of each batch, total number of bytes we want to queue.
  23. DEFBYTES=50000
  24. BYTESQUEUED=1000000000
  25.  
  26. PROG=`basename $0`
  27. LOCK=${LOCKS}/LOCK.${PROGNAME}
  28.  
  29. ##  Go to where the action is.
  30. cd ${BATCH}
  31.  
  32.  
  33. ##  Loop over command line.
  34. for SITE
  35. do
  36.     ##  Is this a flag?
  37.     case "${SITE}" in
  38.     -s*)
  39.     DEFBYTES=`expr "${SITE}" : '-s\(.*\)'`
  40.     continue
  41.     ;;
  42.     -m*)
  43.     BYTESQUEUED=`expr "${SITE}" : '-m\(.*\)'`
  44.     continue
  45.     ;;
  46.     +m)
  47.     BYTESQUEUED=''
  48.     continue
  49.     ;;
  50.     -p*)
  51.     BYTESPERRUN=`expr "${SITE}" : '-p\(.*\)'`
  52.     continue
  53.     ;;
  54.     +p)
  55.     BYTESPERRUN=''
  56.     continue
  57.     ;;
  58.     -r*)
  59.     RNEWS=`expr "${SITE}" : '-r\(.*\)'`
  60.     continue
  61.     ;;
  62.     -U*)
  63.     UUX=`expr "${SITE}" : '-U\(.*\)'`
  64.     continue
  65.     ;;
  66.     -u*)
  67.     UUXFLAGS=`expr "${SITE}" : '-u\(.*\)'`
  68.     continue
  69.     ;;
  70.     -c7)
  71.     COMP="; exec ${COMPRESS} ${COMPFLAGS} | $LIB/encode"
  72.     ECHO="echo '#! c7unbatch'"
  73.     continue
  74.     ;;
  75.     -c)
  76.     COMP="; exec ${COMPRESS} ${COMPFLAGS}"
  77.     ECHO="echo '#! cunbatch'"
  78.     continue
  79.     ;;
  80.     +c)
  81.     COMP=''
  82.     C7=''
  83.     ECHO=''
  84.     COMPFLAGS=''
  85.     continue
  86.     ;;
  87.     -[bBC]*)
  88.     COMPFLAGS="${COMPFLAGS} ${SITE}"
  89.     continue
  90.     ;;
  91.     -o*)
  92.     ECHO=`expr "${SITE}" : '-o\(.*\)'`
  93.     RNEWS='cunbatch'
  94.     continue
  95.     ;;
  96.     +o)
  97.     ECHO=''
  98.     RNEWS=rnews
  99.     continue
  100.     ;;
  101.     -D*)
  102.     UUSPOOL=`expr "${SITE}" : '-D\(.*\)'`
  103.     continue
  104.     ;;
  105.     +D)
  106.     UUSPOOL=''
  107.     continue
  108.     ;;
  109.     -f*)
  110.     SPOOLFREE=`expr "${SITE}" : '-f\(.*\)'`
  111.     continue
  112.     ;;
  113.     esac
  114.     test -z "${BYTESPERRUN}" && BYTESPERRUN=${BYTESQUEUED}
  115.  
  116.     ##  We have a site; lock it.
  117.     LOCK=${LOCKS}/LOCK.${SITE}
  118.     trap 'rm -f ${LOCK} ; exit 1' 1 2 3 15
  119.     shlock -p $$ -f ${LOCK} || {
  120.     echo "${PROG}:  ${SITE} Locked by `cat ${LOCK}`."
  121.     continue
  122.     }
  123.  
  124.     ##  Flush the batchfile.
  125.     BATCHFILE=${BATCH}/${SITE}.uucp
  126.     if [ -f ${SITE}.work ] ; then
  127.     cat ${SITE}.work >>${BATCHFILE}
  128.     rm -f ${SITE}.work
  129.     fi
  130.     mv ${SITE} ${SITE}.work
  131.     ctlinnd -s -t30 flush ${SITE} || {
  132.     echo "${PROG}:  Can't flush ${SITE}."
  133.     rm -f ${LOCK}
  134.     continue
  135.     }
  136.     cat ${SITE}.work >>${BATCHFILE}
  137.     rm -f ${SITE}.work
  138.     if [ ! -s ${BATCHFILE} ] ; then
  139.     echo "${PROG}:  No articles for ${SITE}."
  140.     rm -f ${LOCK}
  141.     continue
  142.     fi
  143.  
  144.     ##  Check free space on the partition?
  145.     if [ -n "${UUSPOOL}" ] ; then
  146.     FREE=`(cd ${UUSPOOL}; df . | ${AWK} '
  147.         $6 == "'${UUSPOOL}'" { print $4 ; exit }
  148.         $1 == "'${UUSPOOL}'" && NF == 7 { print $4 ; exit }
  149.         $2 == "'${UUSPOOL}'" { print $5 ; exit }
  150.         $1 == "'${UUSPOOL}'" { print $3 ; exit }
  151.         ')`
  152.     if [ -n "${FREE}" -a "${FREE}" -lt ${SPOOLFREE} ] ; then
  153.         echo "${PROG}:  No space on ${UUSPOOL} for ${SITE} (${FREE})."
  154.         rm -f ${LOCK}
  155.         continue
  156.     fi
  157.     fi
  158.  
  159.     ##  Check the host's queue size?
  160.     QUEUE=0
  161.     if [ -n "${BYTESQUEUED}" ] ; then
  162.     if [ -d /usr/spool/uucp/${SITE} ] ; then
  163.         # Get queue size from directory size
  164.         QUEUE=`du -s "/usr/spool/uucp/${SITE}" \
  165.             | ${AWK} '{ printf("%s000\n", $1); }'`
  166.  
  167.     else
  168.         ##  Get queue size from uuq command.
  169.         QUEUE=`uuq -l -s${SITE} | ${AWK} '{print $4; exit }'`
  170.     fi
  171.     test -z "${QUEUE}" && QUEUE=0
  172.     if [ "${QUEUE}" -gt ${BYTESQUEUED} ] ; then
  173.         echo "${PROG}:  ${SITE} has ${QUEUE} bytes queued."
  174.         rm -f ${LOCK}
  175.         continue
  176.     fi
  177.     fi
  178.  
  179.     ##  Set how many bytes we can queue this time.
  180.     if [ -z "${BYTESQUEUED}" ] ; then
  181.     BATCHBYTES=${BYTESPERRUN}
  182.     else
  183.     BATCHBYTES=`expr ${BYTESQUEUED} - "${QUEUE}"`
  184.     test ${BATCHBYTES} -gt ${BYTESPERRUN} && BATCHBYTES=${BYTESPERRUN}
  185.     fi
  186.  
  187.     # Say how big each batch should be.  Assume 50% compression.
  188.     if [ -n "${COMP}" ] ; then
  189.     MAXBYTES=`expr ${DEFBYTES} \* 2`
  190.     else
  191.     MAXBYTES=${DEFBYTES}
  192.     fi
  193.  
  194.     ##  Assemble uux command to have batcher(1) run.
  195.     if [ -f ${SITE}.cmd ] ; then
  196.     UUXCOM="`cat ${SITE}.cmd`"
  197.     elif [ -n "${ECHO}" -o -n "${COMP}" ]; then
  198.     UUXCOM="( ${ECHO} ${COMP} ) | ${UUX} - ${UUXFLAGS} ${SITE}!${RNEWS}"
  199.     else
  200.     UUXCOM="${UUX} - ${UUXFLAGS} ${SITE}!${RNEWS}"
  201.     fi
  202.  
  203.     ## Create batches.
  204.     if [ ${BATCHBYTES} -gt 0 ] ; then
  205.     ${NEWSBIN}/batcher -B ${BATCHBYTES} -b ${MAXBYTES} -p "${UUXCOM}" \
  206.         ${SITE} ${BATCHFILE}
  207.     fi
  208.  
  209.     rm -f ${LOCK}
  210. done
  211.